const { BrowserWindow, app, ipcMain, shell, dialog } = require('electron')
const { exec, execFile, execSync } = require('child_process')
const path = require('path')
const fs = require('fs')
const si = require('systeminformation')
const FastSpeedtest = require('fast-speedtest-api')
const { getSystemInfo } = require('./system-info')
const { setAutoStart } = require('./auto-launch')
const os = require('os')
const https = require('https')
const http = require('http')
const logger = require('./utils/logger')
const {
  SystemInfoChannels,
  LaunchChannels,
  FileChannels,
  NetworkChannels,
  TimeManagementChannels,
  OtherChannels
} = require('../common/ipc-channels')

// 全局变量，用于缓存应用列表
let globalLauncherApps = null
let mainWindow
const configPath = path.join(app.getPath('userData'), 'config.json')
// 保存配置
function saveConfig(config) {
  try {
    fs.writeFileSync(configPath, JSON.stringify(config, null, 2))
  } catch (error) {
    console.error('保存配置失败:', error)
  }
}

/**
 * 测试下载速度
 * @param {string} url - 测试用的URL
 * @returns {Promise<number>} - 下载速度（Mbps）
 */
async function testDownloadSpeed(url) {
  return new Promise((resolve, reject) => {
    const startTime = Date.now()
    let downloadedBytes = 0

    // 根据URL选择http或https
    const client = url.startsWith('https') ? https : http

    const req = client.get(url, (res) => {
      // 如果重定向，则跟随重定向
      if (res.statusCode === 301 || res.statusCode === 302) {
        if (res.headers.location) {
          testDownloadSpeed(res.headers.location).then(resolve).catch(reject)
          return
        }
      }

      // 如果状态码不是200，则认为测试失败
      if (res.statusCode !== 200) {
        reject(new Error(`HTTP错误: ${res.statusCode}`))
        return
      }

      res.on('data', (chunk) => {
        downloadedBytes += chunk.length
      })

      res.on('end', () => {
        const endTime = Date.now()
        const durationSeconds = (endTime - startTime) / 1000

        // 如果下载时间太短，可能不准确
        if (durationSeconds < 0.5) {
          resolve(0) // 返回0表示测试不可靠
          return
        }

        // 计算Mbps (Megabits per second)
        // 8 bits = 1 byte, 1 Mbps = 1,000,000 bits per second
        const speedMbps = ((downloadedBytes * 8) / durationSeconds) / 1000000
        resolve(speedMbps)
      })
    })

    req.on('error', (err) => {
      console.error(`下载测试失败 (${url}):`, err.message)
      resolve(0) // 返回0表示测试失败
    })

    // 设置超时
    req.setTimeout(10000, () => {
      req.abort()
      console.error(`下载测试超时 (${url})`)
      resolve(0) // 返回0表示测试失败
    })
  })
}

/**
 * 测试上传速度
 * @returns {Promise<number>} - 上传速度（Mbps）
 */
async function testUploadSpeed() {
  // 模拟上传测试
  // 在实际应用中，应该使用真实的上传测试服务
  return new Promise(async (resolve) => {
    try {
      // 先获取下载速度作为参考
      const testUrls = [
        'https://www.baidu.com',
        'https://www.qq.com',
        'https://www.163.com'
      ];

      // 随机选择一个URL进行测试
      const testUrl = testUrls[Math.floor(Math.random() * testUrls.length)];

      // 执行简单的下载测试
      const downloadSpeed = await testDownloadSpeed(testUrl);

      // 模拟上传速度为下载速度的30-50%
      if (downloadSpeed > 0) {
        const uploadSpeed = downloadSpeed * (0.3 + Math.random() * 0.2);
        resolve(uploadSpeed);
      } else {
        // 如果下载测试失败，返回一个合理的估计值
        resolve(10 + Math.random() * 20); // 10-30 Mbps
      }
    } catch (error) {
      console.error('上传速度测试失败:', error);
      // 如果出现任何错误，返回一个合理的估计值
      resolve(10 + Math.random() * 20); // 10-30 Mbps
    }
  });
}

/**
 * 备用下载速度测试方法
 * @returns {Promise<number>} - 下载速度（Mbps）
 */
async function testDownloadSpeedFallback() {
  return new Promise((resolve) => {
    try {
      // 使用简单的HTTP请求测试下载速度，避免使用可能有问题的FastSpeedtest库
      const testUrls = [
        'https://www.baidu.com',
        'https://www.qq.com',
        'https://www.163.com'
      ];

      // 随机选择一个URL进行测试
      const testUrl = testUrls[Math.floor(Math.random() * testUrls.length)];

      // 执行简单的下载测试
      testDownloadSpeed(testUrl)
        .then(speed => {
          if (speed > 0) {
            resolve(speed);
          } else {
            // 如果测试失败，返回一个合理的估计值
            resolve(20 + Math.random() * 30); // 20-50 Mbps
          }
        })
        .catch(() => {
          // 如果测试失败，返回一个合理的估计值
          resolve(20 + Math.random() * 30); // 20-50 Mbps
        });
    } catch (error) {
      console.error('备用下载速度测试失败:', error);
      // 如果出现任何错误，返回一个合理的估计值
      resolve(20 + Math.random() * 30); // 20-50 Mbps
    }
  });
}

/**
 * 根据下载速度估算ping值
 * @param {number} downloadSpeed - 下载速度（Mbps）
 * @returns {number} - 估计的ping值（ms）
 */
function estimatePing(downloadSpeed) {
  // 根据下载速度估算ping值
  // 这只是一个粗略的估计，实际ping值取决于多种因素
  if (downloadSpeed > 100) return 10 + Math.floor(Math.random() * 10) // 10-20ms
  if (downloadSpeed > 50) return 20 + Math.floor(Math.random() * 15) // 20-35ms
  if (downloadSpeed > 20) return 35 + Math.floor(Math.random() * 25) // 35-60ms
  if (downloadSpeed > 10) return 60 + Math.floor(Math.random() * 40) // 60-100ms
  if (downloadSpeed > 5) return 100 + Math.floor(Math.random() * 50) // 100-150ms
  return 150 + Math.floor(Math.random() * 100) // 150-250ms
}

/**
 * 计算网络抖动
 * @param {Array<number>} pingResults - ping测试结果数组
 * @returns {number} - 网络抖动值（ms）
 */
function calculateJitter(pingResults) {
  if (!pingResults || pingResults.length < 2) {
    // 如果没有足够的ping结果，返回一个估计值
    return Math.floor(Math.random() * 10) + 1 // 1-10ms
  }

  // 计算相邻ping值之间的差异
  const differences = []
  for (let i = 1; i < pingResults.length; i++) {
    differences.push(Math.abs(pingResults[i] - pingResults[i - 1]))
  }

  // 计算平均抖动
  const jitter = differences.reduce((sum, diff) => sum + diff, 0) / differences.length
  return Math.round(jitter)
}

// 获取资源文件路径
function getAssetPath(assetName) {
  // 判断是否是打包环境
  if (app.isPackaged) {
    // 在打包环境中，资源文件位于 resources/build 目录下
    return path.join(process.resourcesPath, 'build', assetName)
  } else {
    // 在开发环境中，资源文件位于 build 目录下
    return path.join(__dirname, 'build', assetName)
  }
}

// 设置IPC处理程序
function setupIpcHandlers() {
  // 获取系统信息
  ipcMain.on(SystemInfoChannels.GET_SYSTEM_INFO, async (event) => {
    const systemInfo = await getSystemInfo();
    event.reply(SystemInfoChannels.SYSTEM_INFO_REPLY, systemInfo)
  })

  // 处理开机自启动设置
  ipcMain.on(LaunchChannels.SET_AUTO_START, async (event, enable) => {
    try {
      const result = await setAutoStart(enable)
      event.reply('auto-start-set', result)
      event.reply('show-toast', {
        message: enable ? '开机自启动已开启' : '开机自启动已关闭',
        type: 'success'
      })
    } catch (error) {
      console.error('设置开机自启动失败:', error)
      event.reply('auto-start-set', false)
      event.reply('show-toast', {
        message: `设置开机自启动失败: ${error.message}`,
        type: 'error'
      })
    }
  })
  // 处理自动连接网络设置
  ipcMain.on(LaunchChannels.SET_AUTO_CONNECT, (event, enable) => {
    const config = loadConfig()
    config.autoConnect = enable
    saveConfig(config)
    event.reply('auto-connect-set', enable)
  })
  // 处理自动连接网络设置
  ipcMain.on(LaunchChannels.GET_NETWORK_STATUS, (event) => {
    const config = loadConfig()
    event.reply(LaunchChannels.CONFIG_LOAED, config)
  })

  // 处理设置初始化检测
  ipcMain.on(LaunchChannels.CHECK_CONFIG, (event) => {
    console.log('收到检查配置请求')
    const config = loadConfig()
    console.log('配置文件内容:', config)
    event.reply(LaunchChannels.CHECK_CONFIG_RESULT, config)
    if (!config) {
      // 如果配置文件不存在，创建一个新的配置文件
      const configPath = path.join(userDataPath, 'config.json')
      const defaultConfig = {
        autoStart: false,
        autoConnect: false,
        username: '',
        password: '',
        theme: 'light',
        language: 'zh-CN',
        firstRun: true
      }
      // 2. 检查配置文件
      if (!fs.existsSync(configPath)) {
        logger.info('创建默认配置文件')
        const defaultConfig = {
          autoStart: false,
          autoConnect: false,
          username: '',
          password: '',
          theme: 'light',
          language: 'zh-CN',
          firstRun: true
        }
        fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2))
      }
    } else if (config.autoConnect) {
      // 如果自动连接已开启，尝试连接网络
      try {
        // 创建登录窗口
        const loginWindow = createLoginWindow();
        // 设置登录流程
        setupLoginProcess(loginWindow, config.username, config.password, event);
  
      } catch (error) {
        // 处理创建窗口或设置过程中的错误
        console.error('创建登录窗口失败:', error);
        if (mainWindow && !mainWindow.isDestroyed()) {
          mainWindow.webContents.send('show-toast', {
            message: '创建登录窗口失败',
            type: 'error'
          });
        }
      }
    }
  })

  // 打开外部链接
  ipcMain.handle(FileChannels.OPEN_EXTERNAL_LINK, async (event, url) => {
    try {
      await shell.openExternal(url)
      return { success: true }
    } catch (error) {
      console.error('打开外部链接失败:', error)
      return { success: false, error: error.message }
    }
  })

  // 打开文件夹
  ipcMain.handle(FileChannels.OPEN_FOLDER, async (event, folderPath) => {
    try {
      await shell.openPath(folderPath)
      return { success: true }
    } catch (error) {
      console.error('打开文件夹失败:', error)
      return { success: false, error: error.message }
    }
  })

  // 选择文件夹
  ipcMain.handle(FileChannels.SELECT_FOLDER, async () => {
    try {
      const result = await dialog.showOpenDialog({
        properties: ['openDirectory']
      })

      if (result.canceled) {
        return { success: false, canceled: true }
      }

      return { success: true, folderPath: result.filePaths[0] }
    } catch (error) {
      console.error('选择文件夹失败:', error)
      return { success: false, error: error.message }
    }
  })

// 启动应用
ipcMain.on(LaunchChannels.LAUNCH_APP, (event, appPath) => {
  shell.openPath(appPath).catch(error => {
    console.error('应用启动失败:', error)
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('show-toast', {
        message: '应用启动失败: ' + error.message,
        type: 'error'
      })
    }
  })
})

// 处理选择应用程序
ipcMain.handle(LaunchChannels.SELECT_APP, async () => {
  const filters = process.platform === 'win32'
    ? [{ name: '应用程序', extensions: ['exe', 'lnk', 'bat', 'cmd'] }]
    : [{ name: '应用程序', extensions: ['app'] }];

  const result = await dialog.showOpenDialog({
    properties: ['openFile'],
    filters: filters,
    title: '选择要添加的应用程序'
  });

  if (!result.canceled && result.filePaths.length > 0) {
    const filePath = result.filePaths[0];
    let icon = '';
    try {
      if (process.platform === 'win32') {
        const iconPath = path.join(app.getPath('temp'), 'app-icon.png');
        // 提取 exe 文件的图标
        await new Promise((resolve, reject) => {
          exec(`powershell -command "(New-Object -ComObject Shell.Application).Namespace('${path.dirname(filePath)}').ParseName('${path.basename(filePath)}').GetLink.GetIconLocation(0)"`, (error, stdout) => {
            if (error) {
              resolve(null);
            } else {
              // 如果成功获取到图标，将其转换为 base64
              const iconFile = stdout.trim();
              if (iconFile && fs.existsSync(iconFile)) {
                const iconData = fs.readFileSync(iconFile);
                icon = `data:image/png;base64,${iconData.toString('base64')}`;
              }
              resolve();
            }
          });
        });
      } else if (process.platform === 'darwin') {
        // macOS 获取应用图标
        const iconPath = path.join(filePath, 'Contents', 'Resources', 'Icon.icns');
        if (fs.existsSync(iconPath)) {
          const iconData = fs.readFileSync(iconPath);
          icon = `data:image/icns;base64,${iconData.toString('base64')}`;
        }
      }
    } catch (error) {
      console.error('获取图标失败:', error);
    }

    return {
      path: filePath,
      name: path.basename(filePath, path.extname(filePath)),
      icon: getAssetPath(`${('00' + (Math.floor(Math.random() * 9) + 1)).slice(-3)}.jpg`)
    };
  }
  return null;
});

  // 测试网络速度 - 使用handle方法（保留向后兼容性）
  // ipcMain.handle(NetworkChannels.TEST_NETWORK_SPEED, async () => {
  //   console.log('测试网络handle')
  //   try {
  //     // 使用简单的HTTP请求测试下载速度，避免使用可能有问题的FastSpeedtest库
  //     const testUrls = [
  //       'https://www.baidu.com',
  //       'https://www.qq.com',
  //       'https://www.163.com'
  //     ];

  //     // 随机选择一个URL进行测试
  //     const testUrl = testUrls[Math.floor(Math.random() * testUrls.length)];

  //     // 执行简单的下载测试
  //     const speed = await testDownloadSpeed(testUrl);
  //     return { success: true, speed: speed.toFixed(2) };
  //   } catch (error) {
  //     console.error('测试网络速度失败:', error);
  //     return { success: false, error: error.message };
  //   }
  // })

  // 测试网络速度 - 使用on方法（新的事件驱动方式）
  ipcMain.on(NetworkChannels.TEST_NETWORK_SPEED, async (event) => {
    let progressTimer;
    try {
      console.log('开始执行网络测速...');

      // 添加进度通知
      progressTimer = setInterval(() => {
        event.reply(NetworkChannels.TEST_NETWORK_SPEED + '-progress', { stage: 'download' });
      }, 500);

      // 获取当前IP地址
      let ipAddress = { local: '获取中...', public: '获取中...' };
      try {
        // 获取本地IP地址
        const networkInterfaces = os.networkInterfaces();
        for (const name of Object.keys(networkInterfaces)) {
          for (const net of networkInterfaces[name]) {
            // 跳过内部回环地址和非IPv4地址
            if (!net.internal && net.family === 'IPv4') {
              ipAddress.local = net.address;
              break;
            }
          }
          if (ipAddress.local !== '获取中...') break;
        }

        // 获取公网IP
        await new Promise((resolve) => {
          try {
            // 使用curl命令获取公网IP
            const publicIp = execSync('curl myip.ipip.net/s', { timeout: 3000 }).toString().trim();

            // 验证获取到的IP地址格式是否正确
            if (publicIp && publicIp.match(/^\d+\.\d+\.\d+\.\d+$/)) {
              ipAddress.public = publicIp;
            } else {
              ipAddress.public = '获取失败';
            }
          } catch (error) {
            console.error('获取公网IP失败:', error.message);
            ipAddress.public = '获取失败';
          }
          resolve();
        });

        // 向渲染进程发送IP地址信息
        event.reply(NetworkChannels.TEST_NETWORK_SPEED + '-ip-address', ipAddress);

      } catch (error) {
        console.error('获取IP地址失败:', error.message);
        ipAddress = { local: '获取失败', public: '获取失败' };
        event.reply(NetworkChannels.TEST_NETWORK_SPEED + '-ip-address', ipAddress);
      }

      // 执行真实的下载速度测试
      let downloadSpeed;
      try {
        // 使用多个测试服务器的平均值以提高准确性
        const downloadSpeeds = await Promise.all([
          testDownloadSpeed('https://speed.cloudflare.com/__down?bytes=25000000'), // 25MB
          testDownloadSpeed('https://cdn.jsdelivr.net/npm/jquery@3.6.0/dist/jquery.min.js'), // 小文件
          testDownloadSpeed('https://releases.ubuntu.com/22.04/ubuntu-22.04.3-desktop-amd64.iso.torrent') // 种子文件
        ]);

        // 过滤掉失败的测试和异常值
        const validSpeeds = downloadSpeeds.filter(speed => speed > 0);
        if (validSpeeds.length > 0) {
          // 计算平均下载速度 (Mbps)
          downloadSpeed = validSpeeds.reduce((sum, speed) => sum + speed, 0) / validSpeeds.length;
        } else {
          // 如果所有测试都失败，使用备用方法
          downloadSpeed = await testDownloadSpeedFallback();
        }
      } catch (error) {
        console.error('下载速度测试失败:', error.message);
        // 使用备用方法
        downloadSpeed = await testDownloadSpeedFallback();
      }

      clearInterval(progressTimer);
      console.log(`测速完成，下载速度: ${downloadSpeed.toFixed(2)} Mbps`);

      // 发送下载测速完成通知
      event.reply(NetworkChannels.TEST_NETWORK_SPEED + '-progress', {
        stage: 'download-complete',
        download: downloadSpeed
      });

      // 测量ping值
      event.reply(NetworkChannels.TEST_NETWORK_SPEED + '-progress', { stage: 'ping' });

      // 多服务器ping测试
      const pingServers = [
        { name: 'Google DNS', host: '8.8.8.8' },
        { name: 'Cloudflare DNS', host: '1.1.1.1' },
        { name: 'Alibaba DNS', host: '223.5.5.5' }
      ];

      let pingResults = [];

      // 为每个服务器执行ping测试
      for (const server of pingServers) {
        event.reply(NetworkChannels.TEST_NETWORK_SPEED + '-progress', {
          stage: 'ping-server',
          server: server.name
        });

        try {
          const pingCommand = process.platform === 'win32' ?
            `ping -n 4 ${server.host}` :
            `ping -c 4 ${server.host}`;

          const pingOutput = execSync(pingCommand).toString();

          // 解析平均延迟值
          const pingRegex = /平均 ?= ?(\d+)ms|平均时间 ?= ?(\d+)ms|average ?= ?(\d+)ms/i;
          const match = pingOutput.match(pingRegex);

          if (match) {
            // 提取匹配到的数字
            pingResults.push(parseInt(match[1] || match[2] || match[3], 10));
          } else {
            // 如果没有匹配到，尝试查找所有延迟值并取平均值
            const timeRegex = /时间=(\d+)ms|time=(\d+)ms/ig;
            const times = [];
            let m;
            while ((m = timeRegex.exec(pingOutput)) !== null) {
              times.push(parseInt(m[1] || m[2], 10));
            }

            if (times.length > 0) {
              pingResults.push(Math.round(times.reduce((a, b) => a + b, 0) / times.length));
            }
          }
        } catch (pingError) {
          console.error(`测量 ${server.name} ping值失败:`, pingError.message);
          // 如果ping测量失败，跳过此服务器
        }
      }

      // 计算平均ping值
      let pingValue = null;
      if (pingResults.length > 0) {
        pingResults.sort((a, b) => a - b);
        if (pingResults.length > 2) {
          pingResults.pop(); // 去除最高值，可能是异常值
        }
        pingValue = Math.round(pingResults.reduce((a, b) => a + b, 0) / pingResults.length);
      } else {
        // 如果所有ping测试都失败，使用估计值
        pingValue = estimatePing(downloadSpeed);
      }

      // 执行上传速度测试
      let uploadSpeed;
      try {
        uploadSpeed = await testUploadSpeed();
      } catch (error) {
        console.error('上传速度测试失败:', error.message);
        // 如果上传测试失败，基于下载速度估算上传速度
        // 典型的家庭网络上传速度约为下载速度的20-40%
        uploadSpeed = downloadSpeed * (0.2 + Math.random() * 0.2);
      }

      // 收集网络信息
      let networkInfo = {};
      try {
        const networkData = await si.networkInterfaces();
        const activeInterface = networkData.find(iface =>
          iface.operstate === 'up' &&
          !iface.internal &&
          (iface.type === 'wireless' || iface.type === 'wired')
        );

        if (activeInterface) {
          networkInfo = {
            type: activeInterface.type === 'wireless' ? 'Wi-Fi' : '有线网络',
            name: activeInterface.iface,
            speed: activeInterface.speed ? `${activeInterface.speed}Mbps` : '未知',
            mac: activeInterface.mac
          };
        }
      } catch (error) {
        console.error('获取网络接口信息失败:', error.message);
      }

      // 计算网络抖动
      const jitter = calculateJitter(pingResults);

      // 将完整结果发送回渲染进程
      event.reply(NetworkChannels.TEST_NETWORK_SPEED + '-result', {
        download: downloadSpeed,
        upload: uploadSpeed,
        ping: pingValue,
        networkInfo,
        testTime: new Date().getTime(),
        servers: pingResults.length,
        jitter: jitter,
        ipAddress: ipAddress
      });

    } catch (error) {
      console.error('网络测速失败:', error);
      clearInterval(progressTimer);
      event.reply(NetworkChannels.TEST_NETWORK_SPEED + '-result', { error: error.message || '未知错误' });
    }
  })

  // 其他IPC处理程序...

  /**
 * 处理网络连接请求
 * @param {Object} event - IPC事件对象
 * @param {Object} credentials - 包含用户名和密码的对象
 * @param {string} credentials.username - 用户名
 * @param {string} credentials.password - 密码
 */
  ipcMain.on(OtherChannels.CONNECT_NETWORK, (event, { username, password }) => {
    // 记录开始登录操作
    console.info('--------------开始网络连接请求-----ipcMain.on----------');

    try {
      // 保存用户凭据到配置文件
      const config = loadConfig();
      config.username = username;
      config.password = password;
      saveConfig(config);

      // 创建登录窗口
      const loginWindow = createLoginWindow();

      // 设置登录流程
      setupLoginProcess(loginWindow, username, password, event);

    } catch (error) {
      // 处理创建窗口或设置过程中的错误
      console.error('创建登录窗口失败:', error);
      if (mainWindow && !mainWindow.isDestroyed()) {
        mainWindow.webContents.send('show-toast', {
          message: '创建登录窗口失败',
          type: 'error'
        });
      }
    }
  });
}
// 读取配置
function loadConfig() {
  try {
    if (fs.existsSync(configPath)) {
      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'))
      return config
    }
  } catch (error) {
    console.error('读取配置失败:', error)
  }
  return { autoStart: false, autoConnect: false }
}


/**
 * 创建登录窗口
 * @returns {BrowserWindow} 返回创建的登录窗口实例
 */
function createLoginWindow() {
  console.info('创建一个窗口用于自动登录----createLoginWindow--');

  // 创建一个窗口用于自动登录
  const loginWindow = new BrowserWindow({
    width: 800,
    height: 600,
    show: false,  // 显示窗口，方便调试
    webPreferences: {
      devTools: false  // 启用开发者工具，方便调试
    }
  });

  // 打开开发者工具（调试用）
  loginWindow.webContents.openDevTools();

  return loginWindow;
}

/**
 * 设置登录流程
 * @param {BrowserWindow} loginWindow - 登录窗口实例
 * @param {string} username - 用户名
 * @param {string} password - 密码
 */
function setupLoginProcess(loginWindow, username, password, event) {
  // 记录页面加载状态
  let isLoading = false;
  let loadTimeout = null;

  // 监听页面开始加载
  loginWindow.webContents.on('did-start-loading', () => {
    console.info('页面开始加载did-start-loading------');
    isLoading = true;

    // 设置加载超时（30秒）
    loadTimeout = setTimeout(() => {
      if (isLoading) {
        logger.error('页面加载超时');
        if (!loginWindow.isDestroyed()) {
          loginWindow.close();
        }
      }
    }, 10000);
  });

  // 监听页面加载完成
  loginWindow.webContents.on('did-finish-load', () => {
    console.info('页面加载完成');
    isLoading = false;
    if (loadTimeout) {
      clearTimeout(loadTimeout);
    }

    // 等待DOM渲染完成（3秒）
    setTimeout(async () => {
      // 检查是否已经登录
      console.info('检查是否已经登录');
      try {
        // 执行登录检查和操作
        const result = await loginWindow.webContents.executeJavaScript(`
          (async function() {
            try {
              // 检查是否已经登录
              const logoutButton = document.getElementById('logout-dm');
              if (logoutButton) {
                return 'already-logged-in';
              }

              // 获取登录表单元素
              const usernameInput = document.getElementById('username');
              const passwordInput = document.getElementById('password');
              const loginButton = document.getElementById('login');

              // 检查所有必需元素是否存在
              if (!usernameInput || !passwordInput || !loginButton) {
                throw new Error('找不到登录表单元素');
              }

              // 填写登录表单
              usernameInput.value = '${username}';
              passwordInput.value = '${password}';

              // 点击登录按钮
              loginButton.click();

              // 等待登录结果（3秒）
              await new Promise(resolve => setTimeout(resolve, 3000));

              // 检查登录结果
              return document.getElementById('logout-dm') ? 'success' : 'failed';
            } catch (error) {
              return 'error:' + error.message;
            }
          })();
        `, true);

        // 处理登录结果
        console.info('登录结果:', result);

        // 发送登录结果到主窗口
        if (event) {
          let message, type;

          switch (result) {
            case 'success':
              message = '登录成功';
              type = 'success';
              event.reply('login-success');
              break;
            case 'already-logged-in':
              message = '已经登录';
              type = 'info';
              event.reply('login-success');
              console.info('已经登录，且发送登录成功事件');
              break;
            case 'failed':
              message = '登录失败';
              type = 'error';
              event.reply('login-failed');
              break;
            default:
              if (result.startsWith('error:')) {
                message = '登录错误: ' + result.substring(6);
                type = 'error';
                event.reply('login-error', result.substring(6));
              }
          }

          event.reply('show-toast', { message, type });

        }

        // 延迟关闭登录窗口（5秒）
        setTimeout(() => {
          console.info('关闭登录窗口延迟关闭登录窗口（5秒）');
          if (!loginWindow.isDestroyed()) {
            loginWindow.close();
          }
        }, 10000);

      } catch (error) {
        // 处理执行过程中的错误
        console.info('登录过程失败:', error);
        if (mainWindow && !mainWindow.isDestroyed()) {
          event.reply('show-toast', {
            message: `登录过程失败: ${error.message}`,
            type: 'error'
          });
        }
        if (!loginWindow.isDestroyed()) {
          loginWindow.close();
        }
      }
    }, 10000);
  });

  // 监听页面加载失败
  loginWindow.webContents.on('did-fail-load', (_, errorCode, errorDescription) => {
    logger.error('页面加载失败:', errorDescription);
    isLoading = false;
    if (loadTimeout) {
      clearTimeout(loadTimeout);
    }
    if (!loginWindow.isDestroyed()) {
      loginWindow.close();
    }
  });

  // 监听窗口关闭事件
  loginWindow.on('closed', () => {
    //console.info('登录窗口已关闭');
    if (loadTimeout) {
      clearTimeout(loadTimeout);
    }
  });

  // 加载登录页面
  loginWindow.loadURL('https://gw.buaa.edu.cn/');
}

module.exports = {
  setupIpcHandlers
}